// #include <opus.h>
// #include <opusenc.h>
// #include <erl_nif.h> 
// #include <stdio.h>
// #include <stdlib.h>
// #include <string.h>

// // 定义错误处理宏
// #define CHECK_NULL(ptr, msg) \
//     if (!(ptr)) { \
//         fprintf(stderr, "Error: %s\n", msg); \
//         return NULL; \
//     }

// #define CHECK_ERROR(cond, msg) \
//     if (!(cond)) { \
//         fprintf(stderr, "Error: %s\n", msg); \
//         return -1; \
//     }

// // 打开文件并检查是否成功
// static FILE* open_file(const char* filename, const char* mode, const char* error_msg) {
//     FILE* file = fopen(filename, mode);
//     CHECK_NULL(file, error_msg);
//     return file;
// }

// // 创建 Opus 编码器
// static OggOpusEnc* create_opus_encoder(FILE* output_file) {
//     OggOpusEnc* enc = ope_encoder_create_file(output_file, NULL, NULL);
//     CHECK_NULL(enc, "Failed to create Opus encoder");
//     return enc;
// }

// // 编码 Ogg 文件到 Opus 流
// static int transcode_ogg_to_opus(FILE* input_file, OggOpusEnc* enc) {
//     unsigned char buffer[4096];
//     int bytes_read;

//     while ((bytes_read = fread(buffer, 1, sizeof(buffer), input_file)) > 0) {
//         int ret = ope_encoder_write(enc, buffer, bytes_read);
//         CHECK_ERROR(ret == 0, "Failed to write data to Opus encoder");
//     }

//     return 0;
// }

// // 定义 NIF 函数
// static ERL_NIF_TERM opus_trans_ogg(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
//     char input_file[256];
//     char output_file[256];

//     // 获取输入文件名
//     if (!enif_get_string(env, argv[0], input_file, sizeof(input_file), ENIF_UTF8)) {
//         return enif_make_badarg(env);
//     }

//     // 获取输出文件名
//     if (!enif_get_string(env, argv[1], output_file, sizeof(output_file), ENIF_UTF8)) {
//         return enif_make_badarg(env);
//     }

//     // 打开输入文件
//     FILE* fp_input = open_file(input_file, "rb", "Failed to open input file");
//     if (!fp_input) {
//         return enif_make_string(env, "Failed to open input file", ERL_NIF_LATIN1);
//     }

//     // 打开输出文件
//     FILE* fp_output = open_file(output_file, "wb", "Failed to open output file");
//     if (!fp_output) {
//         fclose(fp_input);
//         return enif_make_string(env, "Failed to open output file", ERL_NIF_LATIN1);
//     }

//     // 创建 Opus 编码器
//     OggOpusEnc* enc = create_opus_encoder(fp_output);
//     if (!enc) {
//         fclose(fp_input);
//         fclose(fp_output);
//         return enif_make_string(env, "Failed to create Opus encoder", ERL_NIF_LATIN1);
//     }

//     // 编码 Ogg 文件到 Opus 流
//     if (transcode_ogg_to_opus(fp_input, enc) != 0) {
//         ope_encoder_destroy(enc);
//         fclose(fp_input);
//         fclose(fp_output);
//         return enif_make_string(env, "Failed to transcode Ogg to Opus", ERL_NIF_LATIN1);
//     }

//     // 完成编码
//     ope_encoder_drain(enc);
//     ope_encoder_destroy(enc);

//     // 关闭文件
//     fclose(fp_input);
//     fclose(fp_output);

//     return enif_make_atom(env, "ok");
// }

// // NIF 初始化函数
// static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info) {
//     return 0;
// }

// // NIF 卸载函数
// static void unload(ErlNifEnv* env, void* priv_data) {
// }

// // NIF 函数表
// static ErlNifFunc nif_funcs[] = {
//     {"opus_trans_ogg", 2, opus_transcode_nif}
// };

// // NIF 模块定义
// ERL_NIF_INIT(Elixir.SockWorkstation.OpusTransOggNif, nif_funcs, &load, NULL, NULL, &unload);


// #include <opus.h>
// #include <opusenc.h>
// #include <stdio.h>
// #include <stdlib.h>
// #include <string.h>
// #include <erl_nif.h>

// // 定义 NIF 函数
// static ERL_NIF_TERM opus_trans_ogg(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
//     // 获取输入文件名
//     char* input_file;
//     if (!enif_get_string(env, argv[0], &input_file, ENIF_UTF8, 256)) {
//         return enif_make_badarg(env);
//     }

//     // 获取输出文件名
//     char* output_file;
//     if (!enif_get_string(env, argv[1], &output_file, ENIF_UTF8, 256)) {
//         return enif_make_badarg(env);
//     }

//     // 打开输入文件
//     FILE* fp_input = fopen(input_file, "rb");
//     if (!fp_input) {
//         return enif_make_string(env, "Failed to open input file", ERL_NIF_LATIN1);
//     }

//     // 打开输出文件
//     FILE* fp_output = fopen(output_file, "wb");
//     if (!fp_output) {
//         fclose(fp_input);
//         return enif_make_string(env, "Failed to open output file", ERL_NIF_LATIN1);
//     }

//     // 创建 Opus 编码器
//     OggOpusEnc* enc = ope_encoder_create_file(output_file, NULL, 48000, 2, 0, NULL);
//     if (!enc) {
//         fclose(fp_input);
//         fclose(fp_output);
//         return enif_make_string(env, "Failed to create encoder", ERL_NIF_LATIN1);
//     }

//     // 读取输入文件并编码
//     unsigned char buffer[4096];
//     int bytes_read;
//     while ((bytes_read = fread(buffer, 1, sizeof(buffer), fp_input)) > 0) {
//         ope_encoder_write(enc, buffer, bytes_read);
//     }

//     // 完成编码
//     ope_encoder_drain(enc);
//     ope_encoder_destroy(enc);

//     // 关闭文件
//     fclose(fp_input);
//     fclose(fp_output);

//     return enif_make_atom(env, "ok");
// }

// // NIF 初始化函数
// static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info) {
//     return 0;
// }

// // NIF 卸载函数
// static void unload(ErlNifEnv* env, void* priv_data) {
// }

// // NIF 函数表
// static ErlNifFunc nif_funcs[] = {
//     {"opus_trans_ogg", 2, opus_trans_ogg}
// };

// // NIF 模块定义
// ERL_NIF_INIT(Elixir.SockWorkstation.OpusTransOggNif, nif_funcs, &load, NULL, NULL, &unload);

// #include <erl_nif.h>  // Erlang NIF 头文件
// #include <opus.h>
// #include <opusenc.h>
// #include <stdio.h>
// #include <stdlib.h>
// #include <string.h>

// // 定义错误处理宏
// #define CHECK_NULL(ptr, msg) \
//     if (!(ptr)) { \
//         fprintf(stderr, "Error: %s\n", msg); \
//         return NULL; \
//     }

// #define CHECK_ERROR(cond, msg) \
//     if (!(cond)) { \
//         fprintf(stderr, "Error: %s\n", msg); \
//         return -1; \
//     }

// // 创建 Opus 编码器
// static OggOpusEnc* create_opus_encoder(const char* output_file, OggOpusComments* comments, int sample_rate, int channels, int *error) {
//     OggOpusEnc* enc = ope_encoder_create_file(output_file, comments, sample_rate, channels, 0, error);
//     CHECK_NULL(enc, "Failed to create Opus encoder");
//     return enc;
// }

// // 编码 Ogg 二进制流到 Opus 流
// static int ogg_to_opus(const unsigned char* ogg_data, size_t ogg_size, OggOpusEnc* enc) {
//     size_t offset = 0;
//     while (offset < ogg_size) {
//         size_t chunk_size = (ogg_size - offset > 4096) ? 4096 : (ogg_size - offset);
//         int ret = ope_encoder_write(enc, (const opus_int16*)(ogg_data + offset), chunk_size / 2);
//         CHECK_ERROR(ret == 0, "Failed to write data to Opus encoder");
//         offset += chunk_size;
//     }
//     return 0;
// }

// // 定义 NIF 函数
// static ERL_NIF_TERM opus_trans_ogg(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
//     ErlNifBinary ogg_bin;
//     char output_file[256];
//     int sample_rate = 48000;  // 默认采样率
//     int channels = 2;         // 默认声道数

//     // 获取输入的 Ogg 二进制流
//     if (!enif_inspect_binary(env, argv[0], &ogg_bin)) {
//         return enif_make_badarg(env);
//     }

//     // 获取输出文件名
//     if (!enif_get_string(env, argv[1], output_file, sizeof(output_file), ERL_NIF_LATIN1)) {
//         return enif_make_badarg(env);
//     }

//     // 创建 Opus 注释
//     OggOpusComments* comments = ope_comments_create();
//     ope_comments_add(comments, "ARTIST", "Unknown Artist");
//     ope_comments_add(comments, "TITLE", "Unknown Track");

//     // 创建 Opus 编码器
//     int error;
//     OggOpusEnc* enc = create_opus_encoder(output_file, comments, sample_rate, channels, &error);
//     if (!enc) {
//         ope_comments_destroy(comments);
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_string(env, ope_strerror(error), ERL_NIF_LATIN1));
//     }

//     // 编码 Ogg 二进制流到 Opus 流
//     if (opus_trans_ogg(ogg_bin.data, ogg_bin.size, enc) != 0) {
//         ope_encoder_destroy(enc);
//         ope_comments_destroy(comments);
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_string(env, "Failed to transcode Ogg to Opus", ERL_NIF_LATIN1));
//     }

//     // 完成编码
//     ope_encoder_drain(enc);
//     ope_encoder_destroy(enc);
//     ope_comments_destroy(comments);

//     return enif_make_atom(env, "ok");
// }

// // NIF 初始化函数
// static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info) {
//     return 0;
// }

// // NIF 卸载函数
// static void unload(ErlNifEnv* env, void* priv_data) {
// }

// // NIF 函数表
// static ErlNifFunc nif_funcs[] = {
//     {"opus_trans_ogg", 2, opus_trans_ogg}
// };

// // NIF 模块定义
// ERL_NIF_INIT(Elixir.SockWorkstation.OpusTransOggNif, nif_funcs, &load, NULL, NULL, &unload);

// #include <erl_nif.h>  // Erlang NIF 头文件
// #include <opus.h>
// #include "opus/opusenc.h"
// #include <stdio.h>
// #include <stdlib.h>
// #include <string.h>

// // 定义错误处理宏
// #define CHECK_NULL(ptr, msg) \
//     if (!(ptr)) { \
//         fprintf(stderr, "Error: %s\n", msg); \
//         return NULL; \
//     }

// #define CHECK_ERROR(cond, msg) \
//     if (!(cond)) { \
//         fprintf(stderr, "Error: %s\n", msg); \
//         return -1; \
//     }

// // 函数声明
// static int transcode_ogg_to_opus(const unsigned char* ogg_data, size_t ogg_size, OggOpusEnc* enc);

// // 创建 Opus 编码器
// static OggOpusEnc* create_opus_encoder(const char* output_file, OggOpusComments* comments, int sample_rate, int channels, int *error) {
//     OggOpusEnc* enc = ope_encoder_create_file(output_file, comments, sample_rate, channels, 0, error);
//     CHECK_NULL(enc, "Failed to create Opus encoder");
//     return enc;
// }

// // 定义 NIF 函数
// static ERL_NIF_TERM opus_trans_ogg(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
//     ErlNifBinary ogg_bin;
//     char output_file[256];
//     int sample_rate = 16000;  // 默认采样率
//     int channels = 2;         // 默认声道数

//     // 获取输入的 Ogg 二进制流
//     if (!enif_inspect_binary(env, argv[0], &ogg_bin)) {
//         return enif_make_badarg(env);
//     }

//     // 获取输出文件名
//     if (!enif_get_string(env, argv[1], output_file, sizeof(output_file), ERL_NIF_LATIN1)) {
//         return enif_make_badarg(env);
//     }

//     // 创建 Opus 注释
//     OggOpusComments* comments = ope_comments_create();
//     ope_comments_add(comments, "ARTIST", "Unknown Artist");
//     ope_comments_add(comments, "TITLE", "Unknown Track");

//     // 创建 Opus 编码器
//     int error;
//     OggOpusEnc* enc = create_opus_encoder(output_file, comments, sample_rate, channels, &error);
//     if (!enc) {
//         ope_comments_destroy(comments);
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_string(env, ope_strerror(error), ERL_NIF_LATIN1));
//     }

//     // 编码 Ogg 二进制流到 Opus 流
//     if (transcode_ogg_to_opus(ogg_bin.data, ogg_bin.size, enc) != 0) {
//         ope_encoder_destroy(enc);
//         ope_comments_destroy(comments);
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_string(env, "Failed to transcode Ogg to Opus", ERL_NIF_LATIN1));
//     }

//     // 完成编码
//     ope_encoder_drain(enc);
//     ope_encoder_destroy(enc);
//     ope_comments_destroy(comments);

//     return enif_make_atom(env, "ok");
// }

// // 编码 Ogg 二进制流到 Opus 流
// static int transcode_ogg_to_opus(const unsigned char* ogg_data, size_t ogg_size, OggOpusEnc* enc) {
//     size_t offset = 0;
//     while (offset < ogg_size) {
//         size_t chunk_size = (ogg_size - offset > 4096) ? 4096 : (ogg_size - offset);
//         int ret = ope_encoder_write(enc, (const opus_int16*)(ogg_data + offset), chunk_size / 2);  // 假设是 16-bit 音频
//         CHECK_ERROR(ret == 0, "Failed to write data to Opus encoder");
//         offset += chunk_size;
//     }
//     return 0;
// }

// // NIF 初始化函数
// static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info) {
//     return 0;
// }

// // NIF 卸载函数
// static void unload(ErlNifEnv* env, void* priv_data) {
// }

// // NIF 函数表
// static ErlNifFunc nif_funcs[] = {
//     {"opus_trans_ogg", 2, opus_trans_ogg}
// };

// // NIF 模块定义
// ERL_NIF_INIT(Elixir.SockWorkstation.OpusTransOggNif, nif_funcs, &load, NULL, NULL, &unload);

// #include <erl_nif.h>
// #include <opus/opusenc.h>
// #include <stdio.h>
// #include <stdlib.h>
// #include <string.h>

// // 定义错误处理宏
// #define CHECK_NULL(ptr, msg) \
//     if (!(ptr)) { \
//         fprintf(stderr, "Error: %s\n", msg); \
//         return NULL; \
//     }

// #define CHECK_ERROR(cond, msg) \
//     if (!(cond)) { \
//         fprintf(stderr, "Error: %s\n", msg); \
//         return -1; \
//     }

// // 打开文件并检查是否成功
// static FILE* open_file(const char* filename, const char* mode, const char* error_msg) {
//     FILE* file = fopen(filename, mode);
//     CHECK_NULL(file, error_msg);
//     return file;
// }

// // 创建 Opus 编码器
// static OggOpusEnc* create_opus_encoder(const char* output_file, int sample_rate, int channels, int *error) {
//     OggOpusEnc* enc = ope_encoder_create_file(output_file, NULL, sample_rate, channels, 0, error);
//     CHECK_NULL(enc, "Failed to create Opus encoder");
//     return enc;
// }

// // 编码 Ogg 二进制流到 Opus 流
// static int transcode_ogg_to_opus(const unsigned char* ogg_data, size_t ogg_size, OggOpusEnc* enc) {
//     size_t offset = 0;
//     while (offset < ogg_size) {
//         size_t chunk_size = (ogg_size - offset > 4096) ? 4096 : (ogg_size - offset);
//         int ret = ope_encoder_write(enc, (const opus_int16*)(ogg_data + offset), chunk_size / 2);  // 假设是 16-bit 音频
//         CHECK_ERROR(ret == 0, "Failed to write data to Opus encoder");
//         offset += chunk_size;
//     }
//     return 0;
// }

// // 定义 NIF 函数
// static ERL_NIF_TERM ogg_trans_opus(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
//     ErlNifBinary ogg_bin;
//     char output_file[256];
//     int sample_rate = 48000;  // 默认采样率
//     int channels = 2;         // 默认声道数

//     // 获取输入的 Ogg 二进制流
//     if (!enif_inspect_binary(env, argv[0], &ogg_bin)) {
//         return enif_make_badarg(env);
//     }

//     // 获取输出文件名
//     if (!enif_get_string(env, argv[1], output_file, sizeof(output_file), ERL_NIF_LATIN1)) {
//         return enif_make_badarg(env);
//     }

//     // 创建 Opus 编码器
//     int error;
//     OggOpusEnc* enc = create_opus_encoder(output_file, sample_rate, channels, &error);
//     if (!enc) {
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_string(env, ope_strerror(error), ERL_NIF_LATIN1));
//     }

//     // 编码 Ogg 二进制流到 Opus 流
//     if (transcode_ogg_to_opus(ogg_bin.data, ogg_bin.size, enc) != 0) {
//         ope_encoder_destroy(enc);
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_string(env, "Failed to transcode Ogg to Opus", ERL_NIF_LATIN1));
//     }

//     // 完成编码
//     ope_encoder_drain(enc);
//     ope_encoder_destroy(enc);

//     return enif_make_atom(env, "ok");
// }

// // NIF 初始化函数
// static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info) {
//     return 0;
// }

// // NIF 卸载函数
// static void unload(ErlNifEnv* env, void* priv_data) {
// }

// // NIF 函数表
// static ErlNifFunc nif_funcs[] = {
//     {"ogg_trans_opus", 2, ogg_trans_opus}
// };

// // NIF 模块定义
// ERL_NIF_INIT(Elixir.SockWorkstation.OggTransOpusNif, nif_funcs, &load, NULL, NULL, &unload)


// #include <erl_nif.h>
// #include <opus/opus.h>
// #include <opus/opusenc.h>
// #include <opus/opusfile.h>
// #include <stdio.h>
// #include <stdlib.h>
// #include <string.h>

// // 定义错误处理宏
// #define CHECK_NULL(ptr, msg) \
//     if (!(ptr)) { \
//         fprintf(stderr, "Error: %s\n", msg); \
//         return -1; \
//     }

// #define CHECK_ERROR(cond, msg) \
//     if (!(cond)) { \
//         fprintf(stderr, "Error: %s\n", msg); \
//         return -1; \
//     }

// // 创建 Opus 编码器
// static OggOpusEnc* create_opus_encoder(ErlNifEnv* env, ErlNifBinary* output, int sample_rate, int channels) {
//     OggOpusEnc* enc = ope_encoder_create_memory(output->data, output->size, NULL, sample_rate, channels, 0, NULL);
//     CHECK_NULL(enc, "Failed to create Opus encoder");
//     return enc;
// }

// // 编码 Ogg 二进制流到 Opus 流
// static int ogg_to_opus(ErlNifEnv* env, ErlNifBinary* ogg_data, ErlNifBinary* output) {
//     OggOpusFile* of = opus_file_open_memory(ogg_data->data, ogg_data->size, NULL, 0);
//     CHECK_NULL(of, "Failed to open OGG file");

//     int channels = opus_file_get_channels(of);
//     int sample_rate = opus_file_get_rate(of);

//     OggOpusEnc* enc = create_opus_encoder(env, output, sample_rate, channels);
//     CHECK_NULL(enc, "Failed to create Opus encoder");

//     ogg_packet op;
//     op.packet = (unsigned char*)ogg_data->data;
//     op.bytes = ogg_data->size;
//     op.b_o_s = 1;
//     op.e_o_s = 0;
//     op.granulepos = 0;
//     op.packetno = 0;

//     int ret = ope_encoder_write(enc, &op, 0);
//     CHECK_ERROR(ret == 0, "Failed to write data to Opus encoder");

//     opus_file_close(of);
//     ope_encoder_drain(enc);
//     ope_encoder_destroy(enc);

//     return 0;
// }

// // 定义 NIF 函数
// static ERL_NIF_TERM ogg_trans_opus(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
//     ErlNifBinary ogg_bin;
//     ErlNifBinary output_bin;

//     // 获取输入的 Ogg 二进制流
//     if (!enif_inspect_binary(env, argv[0], &ogg_bin)) {
//         return enif_make_badarg(env);
//     }

//     // 初始化输出的 Opus 二进制流
//     output_bin.data = malloc(ogg_bin.size * 2);  // 假设输出大小不会超过输入的两倍
//     output_bin.size = ogg_bin.size * 2;

//     // 编码 Ogg 流到 Opus 流
//     if (ogg_to_opus(env, &ogg_bin, &output_bin) != 0) {
//         free(output_bin.data);
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_string(env, "Failed to transcode Ogg to Opus", ERL_NIF_LATIN1));
//     }

//     // 返回 Opus 二进制流
//     ERL_NIF_TERM output_term = enif_make_binary(env, &output_bin);
//     free(output_bin.data);
//     return enif_make_tuple2(env, enif_make_atom(env, "ok"), output_term);
// }

// // NIF 初始化函数
// static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info) {
//     return 0;
// }

// // NIF 卸载函数
// static void unload(ErlNifEnv* env, void* priv_data) {
// }

// // NIF 函数表
// static ErlNifFunc nif_funcs[] = {
//     {"ogg_trans_opus", 1, ogg_trans_opus}
// };

// // NIF 模块定义
// ERL_NIF_INIT(Elixir.SockWorkstation.OggTransOpusNif, nif_funcs, &load, NULL, NULL, &unload)

// #include <erl_nif.h>
// #include <opus/opusfile.h>
// #include <opus/opusenc.h>
// #include <stdio.h>
// #include <stdlib.h>
// #include <string.h>

// // 定义错误处理宏
// #define CHECK_NULL(ptr, msg) \
//     if (!(ptr)) { \
//         fprintf(stderr, "Error: %s\n", msg); \
//         return -1; \
//     }

// #define CHECK_ERROR(cond, msg) \
//     if (!(cond)) { \
//         fprintf(stderr, "Error: %s\n", msg); \
//         return -1; \
//     }

// // 创建 Opus 编码器
// static OggOpusEnc* create_opus_encoder(ErlNifEnv* env, ErlNifBinary* output, int sample_rate, int channels) {
//     OggOpusEnc* enc = ope_encoder_create_pull(NULL, sample_rate, channels, 0, NULL);
//     CHECK_NULL(enc, "Failed to create Opus encoder");
//     return enc;
// }

// // 编码 Ogg 二进制流到 Opus 流
// static int ogg_to_opus(ErlNifEnv* env, ErlNifBinary* ogg_data, ErlNifBinary* output) {
//     OggOpusFile* of = opus_file_open_memory(ogg_data->data, ogg_data->size, NULL, 0);
//     CHECK_NULL(of, "Failed to open OGG file");

//     int channels = opus_file_get_channels(of);
//     int sample_rate = opus_file_get_rate(of);

//     OggOpusEnc* enc = create_opus_encoder(env, output, sample_rate, channels);
//     CHECK_NULL(enc, "Failed to create Opus encoder");

//     ogg_packet op;
//     op.packet = (unsigned char*)ogg_data->data;
//     op.bytes = ogg_data->size;
//     op.b_o_s = 1;
//     op.e_o_s = 0;
//     op.granulepos = 0;
//     op.packetno = 0;

//     int ret = ope_encoder_write(enc, &op, 0);
//     CHECK_ERROR(ret == 0, "Failed to write data to Opus encoder");

//     opus_file_close(of);
//     ope_encoder_drain(enc);
//     ope_encoder_destroy(enc);

//     return 0;
// }

// // 定义 NIF 函数
// static ERL_NIF_TERM ogg_trans_opus(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
//     ErlNifBinary ogg_bin;
//     ErlNifBinary output_bin;

//     // 获取输入的 Ogg 二进制流
//     if (!enif_inspect_binary(env, argv[0], &ogg_bin)) {
//         return enif_make_badarg(env);
//     }

//     // 初始化输出的 Opus 二进制流
//     output_bin.data = malloc(ogg_bin.size * 2);  // 假设输出大小不会超过输入的两倍
//     output_bin.size = ogg_bin.size * 2;

//     // 编码 Ogg 流到 Opus 流
//     if (ogg_to_opus(env, &ogg_bin, &output_bin) != 0) {
//         free(output_bin.data);
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_string(env, "Failed to transcode Ogg to Opus", ERL_NIF_LATIN1));
//     }

//     // 返回 Opus 二进制流
//     ERL_NIF_TERM output_term = enif_make_binary(env, &output_bin);
//     free(output_bin.data);
//     return enif_make_tuple2(env, enif_make_atom(env, "ok"), output_term);
// }

// // NIF 初始化函数
// static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info) {
//     return 0;
// }

// // NIF 卸载函数
// static void unload(ErlNifEnv* env, void* priv_data) {
// }

// // NIF 函数表
// static ErlNifFunc nif_funcs[] = {
//     {"ogg_trans_opus", 1, ogg_trans_opus}
// };

// // NIF 模块定义
// ERL_NIF_INIT(Elixir.SockWorkstation.OggTransOpusNif, nif_funcs, &load, NULL, NULL, &unload)


// #include <erl_nif.h>
// #include <opus/opusfile.h>
// #include <opus/opusenc.h>
// #include <stdio.h>
// #include <stdlib.h>
// #include <string.h>

// // 定义错误处理宏
// #define CHECK_NULL(ptr, msg) \
//     if (!(ptr)) { \
//         fprintf(stderr, "Error: %s\n", msg); \
//         return NULL; \
//     }

// #define CHECK_ERROR(cond, msg) \
//     if (!(cond)) { \
//         fprintf(stderr, "Error: %s\n", msg); \
//         return -1; \
//     }

// // 创建 Opus 编码器
// static OggOpusEnc* create_opus_encoder(ErlNifEnv* env, int sample_rate, int channels) {
//     int error = 0;
//     OggOpusEnc* enc = ope_encoder_create_pull(NULL, sample_rate, channels, 0, &error);
//     CHECK_NULL(enc, "Failed to create Opus encoder");
//     return enc;
// }

// // 编码 Ogg 二进制流到 Opus 流
// static int ogg_to_opus(ErlNifEnv* env, ErlNifBinary* ogg_data, ErlNifBinary* output) {
//     OggOpusFile* of = op_open_memory(ogg_data->data, ogg_data->size, NULL, NULL, 0);
//     CHECK_NULL(of, "Failed to open OGG file");

//     int channels = op_channel_count(of, -1);
//     int sample_rate = op_head_get_input_sample_rate(of, -1);

//     OggOpusEnc* enc = create_opus_encoder(env, sample_rate, channels);
//     CHECK_NULL(enc, "Failed to create Opus encoder");

//     opus_int16* pcm_buffer = malloc(ogg_data->size * 2);
//     CHECK_NULL(pcm_buffer, "Failed to allocate PCM buffer");

//     int samples_read = op_read_stereo(of, pcm_buffer, ogg_data->size / 2);
//     CHECK_ERROR(samples_read > 0, "Failed to read OGG data");

//     int ret = ope_encoder_write(enc, pcm_buffer, samples_read);
//     CHECK_ERROR(ret == 0, "Failed to write data to Opus encoder");

//     op_free(of);
//     ope_encoder_drain(enc);
//     ope_encoder_destroy(enc);
//     free(pcm_buffer);

//     return 0;
// }

// // 定义 NIF 函数
// static ERL_NIF_TERM ogg_trans_opus(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
//     ErlNifBinary ogg_bin;
//     ErlNifBinary output_bin;

//     // 获取输入的 Ogg 二进制流
//     if (!enif_inspect_binary(env, argv[0], &ogg_bin)) {
//         return enif_make_badarg(env);
//     }

//     // 初始化输出的 Opus 二进制流
//     unsigned char* output_data = enif_make_new_binary(env, ogg_bin.size * 2, &output_bin);
//     CHECK_NULL(output_data, "Failed to allocate output buffer");

//     // 编码 Ogg 流到 Opus 流
//     if (ogg_to_opus(env, &ogg_bin, &output_bin) != 0) {
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_string(env, "Failed to transcode Ogg to Opus", ERL_NIF_LATIN1));
//     }

//     // 返回 Opus 二进制流
//     return enif_make_tuple2(env, enif_make_atom(env, "ok"), enif_make_binary(env, &output_bin));
// }

// // NIF 初始化函数
// static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info) {
//     return 0;
// }

// // NIF 卸载函数
// static void unload(ErlNifEnv* env, void* priv_data) {
// }

// // NIF 函数表
// static ErlNifFunc nif_funcs[] = {
//     {"ogg_trans_opus", 1, ogg_trans_opus}
// };

// // NIF 模块定义
// ERL_NIF_INIT(Elixir.SockWorkstation.OggTransOpusNif, nif_funcs, &load, NULL, NULL, &unload)

// #include <erl_nif.h>
// #include <opus/opusfile.h>
// #include <opus/opusenc.h>
// #include <stdio.h>
// #include <stdlib.h>
// #include <string.h>

// // 定义错误处理宏
// #define CHECK_NULL(ptr, msg) \
//     if (!(ptr)) { \
//         fprintf(stderr, "Error: %s\n", msg); \
//         return NULL; \
//     }

// #define CHECK_ERROR(cond, msg) \
//     if (!(cond)) { \
//         fprintf(stderr, "Error: %s\n", msg); \
//         return -1; \
//     }

// // 创建 Opus 编码器
// static OggOpusEnc* create_opus_encoder(ErlNifEnv* env, ErlNifBinary* output, int sample_rate, int channels) {
//     int error = 0;
//     OggOpusEnc* enc = ope_encoder_create_pull(NULL, sample_rate, channels, 0, &error);
//     CHECK_NULL(enc, "Failed to create Opus encoder");
//     return enc;
// }

// // 编码 Ogg 二进制流到 Opus 流
// static int ogg_to_opus(ErlNifEnv* env, ErlNifBinary* ogg_data, ErlNifBinary* output) {
//     OggOpusFile* of = op_open_memory(ogg_data->data, ogg_data->size, NULL, NULL, 0);
//     CHECK_NULL(of, "Failed to open OGG file");

//     int channels = opus_packet_get_nb_channels(ogg_data->data);
//     int sample_rate = 48000; // 默认采样率

//     OggOpusEnc* enc = create_opus_encoder(env, output, sample_rate, channels);
//     CHECK_NULL(enc, "Failed to create Opus encoder");

//     opus_int16* pcm_buffer = malloc(ogg_data->size * 2);
//     CHECK_NULL(pcm_buffer, "Failed to allocate PCM buffer");

//     int samples_read = op_read_stereo(of, pcm_buffer, ogg_data->size / 2);
//     CHECK_ERROR(samples_read > 0, "Failed to read OGG data");

//     int ret = ope_encoder_write(enc, pcm_buffer, samples_read);
//     CHECK_ERROR(ret == 0, "Failed to write data to Opus encoder");

//     pclose(of);
//     ope_encoder_drain(enc);
//     ope_encoder_destroy(enc);
//     free(pcm_buffer);

//     return 0;
// }

// // 定义 NIF 函数
// static ERL_NIF_TERM ogg_trans_opus(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
//     ErlNifBinary ogg_bin;
//     ErlNifBinary output_bin;

//     // 获取输入的 Ogg 二进制流
//     if (!enif_inspect_binary(env, argv[0], &ogg_bin)) {
//         return enif_make_badarg(env);
//     }

//     // 初始化输出的 Opus 二进制流
//     output_bin.data = malloc(ogg_bin.size * 2);  // 假设输出大小不会超过输入的两倍
//     output_bin.size = ogg_bin.size * 2;

//     // 编码 Ogg 流到 Opus 流
//     if (ogg_to_opus(env, &ogg_bin, &output_bin) != 0) {
//         free(output_bin.data);
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_string(env, "Failed to transcode Ogg to Opus", ERL_NIF_LATIN1));
//     }

//     // 返回 Opus 二进制流
//     ERL_NIF_TERM output_term = enif_make_binary(env, &output_bin);
//     free(output_bin.data);
//     return enif_make_tuple2(env, enif_make_atom(env, "ok"), output_term);
// }

// // NIF 初始化函数
// static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info) {
//     return 0;
// }

// // NIF 卸载函数
// static void unload(ErlNifEnv* env, void* priv_data) {
// }

// // NIF 函数表
// static ErlNifFunc nif_funcs[] = {
//     {"ogg_trans_opus", 1, ogg_trans_opus}
// };

// // NIF 模块定义
// ERL_NIF_INIT(Elixir.SockWorkstation.OggTransOpusNif, nif_funcs, &load, NULL, NULL, &unload)

// #include <erl_nif.h>
// #include <opus/opusfile.h>
// #include <opus/opusenc.h>
// #include <stdio.h>
// #include <stdlib.h>
// #include <string.h>

// // 定义错误处理宏
// #define CHECK_NULL(ptr, msg) \
//     if (!(ptr)) { \
//         fprintf(stderr, "Error: %s\n", msg); \
//         return NULL; \
//     }

// #define CHECK_ERROR(cond, msg) \
//     if (!(cond)) { \
//         fprintf(stderr, "Error: %s\n", msg); \
//         return -1; \
//     }

// // 创建 Opus 编码器
// static OggOpusEnc* create_opus_encoder(ErlNifEnv* env, ErlNifBinary* output, int sample_rate, int channels) {
//     int error = 0;
//     OggOpusEnc* enc = ope_encoder_create_pull(NULL, sample_rate, channels, 0, &error);
//     CHECK_NULL(enc, "Failed to create Opus encoder");
//     return enc;
// }
// // 编码 Ogg 二进制流到 Opus 流
// static int ogg_to_opus(ErlNifEnv* env, ErlNifBinary* ogg_data, ErlNifBinary* output) {
//     OggOpusFile* of = op_open_memory(ogg_data->data, ogg_data->size,  0);
//     CHECK_NULL(of, "Failed to open OGG file");

//     int channels = op_head_get_input_sample_rate(op_head(of, -1));
//     int sample_rate = 48000; // 默认采样率

//     OggOpusEnc* enc = create_opus_encoder(env, output, sample_rate, channels);
//     CHECK_NULL(enc, "Failed to create Opus encoder");

//     opus_int16* pcm_buffer = malloc(ogg_data->size * 2);
//     CHECK_NULL(pcm_buffer, "Failed to allocate PCM buffer");

//     int samples_read = op_read_stereo(of, pcm_buffer, ogg_data->size / 2);
//     CHECK_ERROR(samples_read > 0, "Failed to read OGG data");

//     int ret = ope_encoder_write(enc, pcm_buffer, samples_read);
//     CHECK_ERROR(ret == 0, "Failed to write data to Opus encoder");

//     pclose(of);
//     ope_encoder_drain(enc);
//     ope_encoder_destroy(enc);
//     free(pcm_buffer);

//     return 0;
// }

// // 定义 NIF 函数
// static ERL_NIF_TERM ogg_trans_opus(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
//     ErlNifBinary ogg_bin;
//     ErlNifBinary output_bin;

//     // 获取输入的 Ogg 二进制流
//     if (!enif_inspect_binary(env, argv[0], &ogg_bin)) {
//         return enif_make_badarg(env);
//     }

//     // 初始化输出的 Opus 二进制流
//     output_bin.data = malloc(ogg_bin.size * 2);  // 假设输出大小不会超过输入的两倍
//     output_bin.size = ogg_bin.size * 2;

//     // 编码 Ogg 流到 Opus 流
//     if (ogg_to_opus(env, &ogg_bin, &output_bin) != 0) {
//         free(output_bin.data);
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_string(env, "Failed to transcode Ogg to Opus", ERL_NIF_LATIN1));
//     }

//     // 返回 Opus 二进制流
//     unsigned char* output_data;
//     ERL_NIF_TERM output_term;
//     output_data = enif_make_new_binary(env, output_bin.size, &output_term);
//     memcpy(output_data, output_bin.data, output_bin.size);
//     free(output_bin.data);
//     return enif_make_tuple2(env, enif_make_atom(env, "ok"), output_term);
// }

// // NIF 初始化函数
// static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info) {
//     return 0;
// }

// // NIF 卸载函数
// static void unload(ErlNifEnv* env, void* priv_data) {
// }

// // NIF 函数表
// static ErlNifFunc nif_funcs[] = {
//     {"ogg_trans_opus", 1, ogg_trans_opus}
// };

// // NIF 模块定义
// ERL_NIF_INIT(Elixir.SockWorkstation.OggTransOpusNif, nif_funcs, &load, NULL, NULL, &unload)


#include <erl_nif.h>
#include <opus/opusfile.h>
#include <opus/opusenc.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 定义错误处理宏
#define CHECK_NULL(ptr, msg) \
    if (!(ptr)) { \
        fprintf(stderr, "Error: %s\n", msg); \
        return NULL; \
    }

#define CHECK_ERROR(cond, msg) \
    if (!(cond)) { \
        fprintf(stderr, "Error: %s\n", msg); \
        return -1; \
    }

// 创建 Opus 编码器
static OggOpusEnc* create_opus_encoder(ErlNifEnv* env, ErlNifBinary* output, int sample_rate, int channels) {
    int error = 0;
    OggOpusEnc* enc = ope_encoder_create_pull(NULL, sample_rate, channels, 0, &error);
    CHECK_NULL(enc, "Failed to create Opus encoder");
    return enc;
}

// 编码 Ogg 二进制流到 Opus 流
static int ogg_to_opus(ErlNifEnv* env, ErlNifBinary* ogg_data, ErlNifBinary* output) {
    OggOpusFile* of = op_open_memory(ogg_data->data, ogg_data->size, 0);
    CHECK_NULL(of, "Failed to open OGG file");

    // int channels = op_head_get_input_sample_rate(op_head(of, -1));
    // int sample_rate = 48000; // 默认采样率

    int channels = 1;
    int sample_rate = 16000;

    OggOpusEnc* enc = create_opus_encoder(env, output, sample_rate, channels);
    CHECK_NULL(enc, "Failed to create Opus encoder");

    opus_int16* pcm_buffer = malloc(ogg_data->size * 2);
    CHECK_NULL(pcm_buffer, "Failed to allocate PCM buffer");

    int samples_read = op_read_stereo(of, pcm_buffer, ogg_data->size / 2);
    CHECK_ERROR(samples_read > 0, "Failed to read OGG data");

    int ret = ope_encoder_write(enc, pcm_buffer, samples_read);
    CHECK_ERROR(ret == 0, "Failed to write data to Opus encoder");

    op_free(of);
    ope_encoder_drain(enc);
    ope_encoder_destroy(enc);
    free(pcm_buffer);

    return 0;
}

// 定义 NIF 函数
static ERL_NIF_TERM ogg_trans_opus(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
    ErlNifBinary ogg_bin;
    ErlNifBinary output_bin;

    // 获取输入的 Ogg 二进制流
    if (!enif_inspect_binary(env, argv[0], &ogg_bin)) {
        return enif_make_badarg(env);
    }

    // 初始化输出的 Opus 二进制流
    output_bin.data = malloc(ogg_bin.size * 2);  // 假设输出大小不会超过输入的两倍
    output_bin.size = ogg_bin.size * 2;

    // 编码 Ogg 流到 Opus 流
    if (ogg_to_opus(env, &ogg_bin, &output_bin) != 0) {
        free(output_bin.data);
        return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_string(env, "Failed to transcode Ogg to Opus", ERL_NIF_LATIN1));
    }

    // 返回 Opus 二进制流
    unsigned char* output_data;
    ERL_NIF_TERM output_term;
    output_data = enif_make_new_binary(env, output_bin.size, &output_term);
    memcpy(output_data, output_bin.data, output_bin.size);
    free(output_bin.data);
    return enif_make_tuple2(env, enif_make_atom(env, "ok"), output_term);
}

// NIF 初始化函数
static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info) {
    return 0;
}

// NIF 卸载函数
static void unload(ErlNifEnv* env, void* priv_data) {
}

// NIF 函数表
static ErlNifFunc nif_funcs[] = {
    {"ogg_trans_opus", 1, ogg_trans_opus}
};

// NIF 模块定义
ERL_NIF_INIT(Elixir.SockWorkstation.OggTransOpusNif, nif_funcs, &load, NULL, NULL, &unload)